//
// Created by twetec on 25-6-21.
//

#ifndef NETWORK_PROBER_DATABASE_MEMORY_DB_HANDLER_H
#define NETWORK_PROBER_DATABASE_MEMORY_DB_HANDLER_H

#include <duckdb.h>

#include "memory_db_model.h"

namespace network_prober::database
{
class MemoryDBHolder
{
public:
    /**
     * 批量添加观测目标
     * @param observedTargets
     */
    void batchInsertObservedTargets(const std::vector<ObservedTargetModel>& observedTargets);

    /**
     * 根据网口名，删除观测目标
     */
    void batchRemoveObservedTargetsByInterfaceName(const std::string& interfaceName);

    /**
     * 根据设备UUID，删除观测目标(逗号分隔)
     */
    void batchRemoveObservedTargetsByUUIDs(const std::vector<std::string>& uuids);

    /**
     * 删除所有观测目标
     */
    void batchRemoveAllObservedTargets();

    /**
     * 获取所有的观测设备
     */
    std::vector<ObservedTargetModel> getAllObservedTargets();

    /**
     * 批量添加备份目标
     * @param observedTargets
     */
    void batchInsertDevices(const std::vector<DeviceModel>& devices);

    /**
     * 根据网口名，删除备份目标
     */
    void batchRemoveDevicesByInterfaceName(const std::string& interfaceName);

    /**
     * 根据设备UUID，删除备份目标(逗号分隔)
     */
    void batchRemoveDevicesByUUIDs(const std::vector<std::string>& uuids);

    /**
     * 删除所有备份目标
     */
    void batchRemoveAllDevices();

    /**
     * 获取所有的备份设备
     */
    std::vector<DeviceModel> getAllDevices();

    /**
     * 批量新增观测任务
     */
    void batchInsertProbeTasks(std::span<ProbeTaskModel> probeTasks);

    /**
     * 批量新增备份任务
     */
    void batchInsertBackupTasks(std::span<BackupTaskModel> backupTasks);

    /**
     * 删除所有 观测任务
     */
    void batchRemoveAllProbeTasks();

    /**
     * 新增观测目标
     */
    void insertObservedTarget(const ObservedTargetModel& target);

    /**
     * 更新观测目标
     */
    void updateObservedTarget(const ObservedTargetModel& target);

    /**
     * 删除观测目标
     */
    void removeObservedTargetByUUID(std::string_view uuid);

    /**
     * 新增备份目标
     */
    void insertDevice(const DeviceModel& device);

    /**
     *  更新观测目标
     */
    void updateDevice(const DeviceModel& device);

    /**
     * 新增备份结果
     */
    void insertBackupTaskResult(std::string_view uuid, std::string_view backupData, std::int64_t backupDate);

    /**
     * 更新备份结果
     */
    void updateBackupTaskResult(std::string_view uuid, std::string_view backupData, std::int64_t backupDate);

    /**
     * 批量新增备份数据
     */
    void batchInsertBackupTaskResults(std::span<BackupTaskResultModel> backupTaskResults);

    /**
     * 获取所有备份任务
     */
    std::vector<database::BackupTaskModel> getAllBackupTasks();

    /**
     * 获取所有观测任务
     */
    std::vector<database::ProbeTaskModel> getAllProbeTasks();

    /**
     * 删除所有 备份任务
     */
    void batchRemoveAllBackupTasks();

    /**
     * 删除备份目标
     */
    void removeDeviceByUUID(std::string_view uuid);

    /**
     * 删除备份数据
     */
    void removeBackupTaskResultByUUID(std::string_view uuid);

    /**
     * 获取备份数据
     */
    BackupTaskResultModel getBackupTaskResultByUUID(std::string_view uuid);

    /**
     * 获取所有备份数据
     */
    std::vector<BackupTaskResultModel> getAllBackupTaskResults();

    void init();                       // 初始化
    static MemoryDBHolder &getInstance(); // 获取实例

private:
    void _initObservedTargetTable();
    void _initDeviceTable();
    void _initProbeTaskTable();
    void _initBackupTaskTable();
    void _initBackupTaskResultTable();

    MemoryDBHolder();  // 构造函数私有化
    ~MemoryDBHolder(); // 析构函数私有化

    MemoryDBHolder(const MemoryDBHolder &) = delete;            // 禁用默认拷贝构造函数（初始化赋值时调用）
    MemoryDBHolder &operator=(const MemoryDBHolder &) = delete; // 禁用默认拷贝赋值（初始化后，再赋值时调用）

    MemoryDBHolder(MemoryDBHolder &&) = delete;            // 搬运构造
    MemoryDBHolder &operator=(MemoryDBHolder &&) = delete; // 搬运赋值

private:
    duckdb_database m_db;
};
}

#endif //NETWORK_PROBER_DATABASE_MEMORY_DB_HANDLER_H
